package com.zj.osm.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Environment;
import android.util.Log;
import com.blankj.utilcode.util.SPUtils;
import com.google.android.gms.maps.model.LatLng;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 项目中常用到的工具类
 */
public class MyUtils {
    /**
     * 壓縮Bitmap
     */
    public static Bitmap zoomImg(Bitmap bm, int newWidth, int newHeight) {
        //获得图片的宽高
        int width = bm.getWidth();
        int height = bm.getHeight();
        //计算缩放比例
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        //取得想要缩放的matrix参数
        Matrix matrix = new Matrix();
        matrix.postScale(scaleWidth, scaleHeight);
        //得到新的图片
        return Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
    }

    /**
     * 比较两个日期的大小，日期格式为yyyy-MM-dd
     *
     * @param str1 the first date
     * @param str2 the second date
     * @return true <br/>false
     */
    public static boolean isDateOneBigger(String str1, String str2) {
        boolean isBigger = false;
        @SuppressLint("SimpleDateFormat") SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date dt1 = null;
        Date dt2 = null;
        try {
            dt1 = sdf.parse(str1);
            dt2 = sdf.parse(str2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        assert dt2 != null;
        if (dt1.getTime() > dt2.getTime()) {
            isBigger = true;
        } else if (dt1.getTime() < dt2.getTime()) {
            isBigger = false;
        }
        return isBigger;
    }


    /**
     * 获取两经纬度点之间的直线距离
     */
    public static Double Distance(double lat1, double lng1, double lat2, double lng2) {

        Double R = 6370996.81;  //地球的半径
        //获取两点间x,y轴之间的距离
        double x = (lng2 - lng1) * Math.PI * R * Math.cos(((lat1 + lat2) / 2) * Math.PI / 180) / 180;
        double y = (lat2 - lat1) * Math.PI * R / 180;
        //得到两点之间的直线距离

        return Math.hypot(x, y);
    }

    /**
     * 获取两经纬度点之间的直线距离
     */
    public static Double Distance(String latA, String lngA, String latB, String lngB) {
        try {
            Double lat1 = Double.parseDouble(latA);
            Double lng1 = Double.parseDouble(lngA);
            Double lat2 = Double.parseDouble(latB);
            Double lng2 = Double.parseDouble(lngB);

            Double R = 6370996.81;  //地球的半径
            //获取两点间x,y轴之间的距离
            double x = (lng2 - lng1) * Math.PI * R * Math.cos(((lat1 + lat2) / 2) * Math.PI / 180) / 180;
            double y = (lat2 - lat1) * Math.PI * R / 180;
            //得到两点之间的直线距离

            return Math.hypot(x, y);
        } catch (Exception e) {
            return 0.0;
        }
    }


    /**
     * 获取两点之间经纬度的角度
     *
     * @param lat1 经度
     * @param lon1 纬度
     * @param lat2 /
     * @param lon2 /
     * @return 角度
     */
    public static double bearing(double lat1, double lon1, double lat2, double lon2) {
        double latitude1 = Math.toRadians(lat1);
        double latitude2 = Math.toRadians(lat2);
        double longDiff = Math.toRadians(lon2 - lon1);
        double y = Math.sin(longDiff) * Math.cos(latitude2);
        double x = Math.cos(latitude1) * Math.sin(latitude2) - Math.sin(latitude1) * Math.cos(latitude2) * Math.cos(longDiff);
        return (Math.toDegrees(Math.atan2(y, x)) + 360) % 180;
    }


    /**
     * 计算两个坐标之间的角度
     *
     * @param start 起点
     * @param end   终点
     */
    public static float rotation(LatLng start, LatLng end) {
        //方向一致化
        LatLng swap;
        if (end.longitude - start.longitude < 0) {
            swap = end;
            end = start;
            start = swap;
        }

        double angle = Math.atan2((end.latitude - start.latitude), (end.longitude - start.longitude));
        return (float) (angle * (180 / Math.PI));
    }
    /**
     * 计算两点之间等距的经纬度
     */
    public List<LatLng> getDengLatLng(int number, LatLng latLng_a, LatLng latLng_b) {
        double aaa, bbb, ccc = 0, ddd = 0;
        List<LatLng> latLngs = new ArrayList<>();
        double mlat = (latLng_b.latitude - latLng_a.latitude) / number, mlng = (latLng_b.longitude - latLng_a.longitude) / number;
        for (int i = 0; i <= number; i++) {
            aaa = latLng_a.latitude + i * mlat;
            bbb = latLng_a.longitude + i * mlng;
            LatLng latLng = new LatLng(aaa, bbb);
            Log.e("hahaha=" + i, latLng.toString());
            latLngs.add(latLng);
        }
        for (int i = 1; i < number + 1; i++) {
            if (latLng_a.longitude > latLng_b.longitude && latLng_a.latitude > latLng_b.latitude) {
                aaa = (latLng_a.longitude - latLng_b.longitude) / (number);
                ccc = latLng_b.longitude + aaa * (i);
                bbb = (latLng_a.latitude - latLng_b.latitude) / (number);
                ddd = bbb * (i) + latLng_b.latitude;

            } else if (latLng_a.longitude < latLng_b.longitude && latLng_a.latitude < latLng_b.latitude) {
                aaa = (latLng_b.longitude - latLng_a.longitude) / (number);
                ccc = latLng_a.longitude + aaa * (i);
                bbb = (latLng_b.latitude - latLng_a.latitude) / (number);
                ddd = latLng_a.latitude + bbb * i;

            } else if (latLng_a.longitude > latLng_b.longitude && latLng_a.latitude < latLng_b.latitude) {
                aaa = (latLng_a.longitude - latLng_b.longitude) / (number);
                ccc = latLng_b.longitude + aaa * (number - i);
                bbb = (latLng_b.latitude - latLng_a.latitude) / (number);
                ddd = latLng_a.latitude + bbb * i;

            } else if (latLng_a.longitude < latLng_b.longitude && latLng_a.latitude > latLng_b.latitude) {
                aaa = (latLng_b.longitude - latLng_a.longitude) / (number);
                ccc = latLng_a.longitude + aaa * (i);
                bbb = (latLng_a.latitude - latLng_b.latitude) / (number);
                ddd = latLng_a.latitude - bbb * i;

            }

            latLngs.add(new LatLng(ddd, ccc));
        }
        return latLngs;
    }

    /**
     * xml文件转换字符串
     *
     * @param path 文件路径
     * @return /
     */
    public static String xmlFileToStr(String path) {
        String xmlString;
        byte[] strBuffer = null;
        InputStream in;
        int flen;
        File xmlfile = new File(path);
        try {
            in = new FileInputStream(xmlfile);
            flen = (int) xmlfile.length();
            strBuffer = new byte[flen];
            in.read(strBuffer, 0, flen);
            in.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        assert strBuffer != null;
        xmlString = new String(strBuffer); //构建String时，可用byte[]类型，
        return xmlString;
    }


}
